#if 0
#include "cvariant.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <ctype.h>
#include <sys/stat.h>

// 进程信息结构体（使用variant存储多类型数据）
typedef struct {
    CVariant* pid;        // 整数
    CVariant* name;       // 字符串
    CVariant* state;      // 字符串（R/S/Z等）
    CVariant* ppid;       // 整数（父进程ID）
    CVariant* vsize;      // 整数（虚拟内存，字节）
    CVariant* rss;        // 整数（物理内存，页）
    CVariant* cpu_usage;  // 浮点数（CPU使用率，%）
} ProcInfo;

// 系统信息结构体
typedef struct {
    CVariant* total_mem;  // 整数（总内存，KB）
    CVariant* free_mem;   // 整数（空闲内存，KB）
    CVariant* load_avg;   // 字符串（1/5/15分钟负载）
} SysInfo;

// 初始化进程信息
static ProcInfo* procinfo_init() {
    ProcInfo* info = (ProcInfo*)malloc(sizeof(ProcInfo));
    info->pid = cvariant_create();
    info->name = cvariant_create();
    info->state = cvariant_create();
    info->ppid = cvariant_create();
    info->vsize = cvariant_create();
    info->rss = cvariant_create();
    info->cpu_usage = cvariant_create();
    return info;
}

// 释放进程信息
static void procinfo_free(ProcInfo* info) {
    cvariant_destroy(info->pid);
    cvariant_destroy(info->name);
    cvariant_destroy(info->state);
    cvariant_destroy(info->ppid);
    cvariant_destroy(info->vsize);
    cvariant_destroy(info->rss);
    cvariant_destroy(info->cpu_usage);
    free(info);
}

// 初始化系统信息
static SysInfo* sysinfo_init() {
    SysInfo* info = (SysInfo*)malloc(sizeof(SysInfo));
    info->total_mem = cvariant_create();
    info->free_mem = cvariant_create();
    info->load_avg = cvariant_create();
    return info;
}

// 释放系统信息
static void sysinfo_free(SysInfo* info) {
    cvariant_destroy(info->total_mem);
    cvariant_destroy(info->free_mem);
    cvariant_destroy(info->load_avg);
    free(info);
}

// 解析/proc/[pid]/stat获取进程基本信息
static int parse_proc_stat(const char* pid, ProcInfo* info) {
    char path[256];
    snprintf(path, sizeof(path), "/proc/%s/stat", pid);
    FILE* f = fopen(path, "r");
    if (!f) return -1;

    // stat格式：pid comm state ppid ... vsize rss ...
    char comm[256];
    char state;
    int ppid, vsize, rss;
    if (fscanf(f, "%d %s %c %d ... %d %d",  // 省略中间无关字段
        &(int){0}, comm, &state, &ppid, &vsize, &rss) < 6) {
        fclose(f);
        return -1;
    }
    fclose(f);

    // 存储到variant（多类型管理）
    cvariant_set_int(info->pid, atoi(pid));
    cvariant_set_str(info->name, comm + 1);  // 去掉comm的括号
    cvariant_set_str(info->state, (char[]){state, '\0'});  // 状态字符转字符串
    cvariant_set_int(info->ppid, ppid);
    cvariant_set_int(info->vsize, vsize);
    cvariant_set_int(info->rss, rss);

    // 简单计算CPU使用率（示例，实际需对比时间差）
    cvariant_set_double(info->cpu_usage, (rand() % 1000) / 10.0);  // 模拟0-100%
    return 0;
}

// 解析/proc/meminfo获取内存信息
static int parse_meminfo(SysInfo* info) {
    FILE* f = fopen("/proc/meminfo", "r");
    if (!f) return -1;

    char line[256];
    int total = 0, free = 0;
    while (fgets(line, sizeof(line), f)) {
        if (strncmp(line, "MemTotal:", 9) == 0) {
            sscanf(line, "MemTotal: %d kB", &total);
        } else if (strncmp(line, "MemFree:", 8) == 0) {
            sscanf(line, "MemFree: %d kB", &free);
        }
    }
    fclose(f);

    cvariant_set_int(info->total_mem, total);
    cvariant_set_int(info->free_mem, free);
    return 0;
}

// 解析/proc/loadavg获取系统负载
static int parse_loadavg(SysInfo* info) {
    FILE* f = fopen("/proc/loadavg", "r");
    if (!f) return -1;

    char avg[64];
    fscanf(f, "%s", avg);  // 读取1分钟负载
    fclose(f);
    cvariant_set_str(info->load_avg, avg);
    return 0;
}

// 列出所有进程PID（遍历/proc目录）
static void list_all_pids() {
    DIR* dir = opendir("/proc");
    if (!dir) return;

    struct dirent* entry;
    printf("PID  名称      状态  父进程  物理内存(页)\n");
    printf("-----------------------------------------\n");
    while ((entry = readdir(dir)) != NULL) {
        if (isdigit(entry->d_name[0])) {  // /proc下数字目录为进程PID
            ProcInfo* info = procinfo_init();
            if (parse_proc_stat(entry->d_name, info) == 0) {
                // 从variant中读取多类型数据并输出
                printf("%-4d %-8s %-4s %-6d %-8d\n",
                    cvariant_get_int(info->pid),
                    cvariant_get_str(info->name),
                    cvariant_get_str(info->state),
                    cvariant_get_int(info->ppid),
                    cvariant_get_int(info->rss));
            }
            procinfo_free(info);
        }
    }
    closedir(dir);
}

// 显示单个进程详细信息
static void show_proc_detail(const char* pid) {
    ProcInfo* info = procinfo_init();
    if (parse_proc_stat(pid, info) != 0) {
        fprintf(stderr, "错误：进程 %s 不存在\n", pid);
        procinfo_free(info);
        return;
    }

    printf("进程详细信息 (PID: %d)\n", cvariant_get_int(info->pid));
    printf("-----------------------------------------\n");
    printf("名称:       %s\n", cvariant_get_str(info->name));
    printf("状态:       %s (R=运行, S=睡眠, Z=僵尸)\n", cvariant_get_str(info->state));
    printf("父进程ID:   %d\n", cvariant_get_int(info->ppid));
    printf("虚拟内存:   %d 字节\n", cvariant_get_int(info->vsize));
    printf("物理内存:   %d 页 (约 %d KB)\n",
        cvariant_get_int(info->rss),
        cvariant_get_int(info->rss) * getpagesize() / 1024);  // 页转KB
    printf("CPU使用率:  %.1f%%\n", cvariant_get_double(info->cpu_usage));

    procinfo_free(info);
}

// 显示系统信息
static void show_sysinfo() {
    SysInfo* info = sysinfo_init();
    if (parse_meminfo(info) != 0 || parse_loadavg(info) != 0) {
        fprintf(stderr, "错误：无法读取系统信息\n");
        sysinfo_free(info);
        return;
    }

    int total = cvariant_get_int(info->total_mem);
    int free = cvariant_get_int(info->free_mem);
    int used = total - free;

    printf("系统信息\n");
    printf("-----------------------------------------\n");
    printf("内存总量:   %d KB\n", total);
    printf("空闲内存:   %d KB\n", free);
    printf("已用内存:   %d KB (%.1f%%)\n",
        used, (used * 100.0) / total);
    printf("1分钟负载:  %s\n", cvariant_get_str(info->load_avg));

    sysinfo_free(info);
}

// 显示帮助信息
static void print_help(const char* progname) {
    printf("用法：%s [选项]\n", progname);
    printf("Linux /proc 文件系统解析工具\n");
    printf("选项:\n");
    printf("  -l          列出所有进程简要信息\n");
    printf("  -p <pid>    显示指定进程的详细信息\n");
    printf("  -s          显示系统内存和负载信息\n");
    printf("  -h          显示帮助\n");
    printf("示例:\n");
    printf("  %s -l              # 列出所有进程\n", progname);
    printf("  %s -p 1            # 显示进程1（init/systemd）的详情\n", progname);
    printf("  %s -s              # 显示系统内存使用情况\n", progname);
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        print_help(argv[0]);
        return 1;
    }

    // 解析命令行参数
    if (strcmp(argv[1], "-l") == 0) {
        list_all_pids();
    } else if (strcmp(argv[1], "-p") == 0 && argc >= 3) {
        show_proc_detail(argv[2]);
    } else if (strcmp(argv[1], "-s") == 0) {
        show_sysinfo();
    } else if (strcmp(argv[1], "-h") == 0) {
        print_help(argv[0]);
    } else {
        fprintf(stderr, "未知选项: %s\n", argv[1]);
        print_help(argv[0]);
        return 1;
    }

    return 0;
}
#endif